// 引入日期时间处理工具
// const dateTimePicker = require('../../utils/dateTimePicker.js');
// const lunarCalendar = require('../../utils/lunar.js');

Page({
  data: {
    dateTimeArray: null,
    dateTimeIndex: null,
    lunarDate: '',
    gender: 'male',
    birthplace: '',
    lastName: '',
    preference: 'zodiac', // 默认选择传统派1
    isFormValid: false,
    surname: '',
    nameLength: 'double',
    fixedChar: false,
    fixedPosition: 'first',
    fixedCharValue: '',
    disableRareChars: true,
    disableComplexChars: true,
    selectedPreference: '',
    formComplete: false,
    showBirthSelector: false,
    hasUserInfo: false, // 用户信息状态
    userInfo: null, // 用户信息
    isTwins: false, // 默认为单胞胎
    genderCombination: 'male-male' // 默认性别组合为男男
  },

  onLoad: function() {
    // 初始化日期时间选择器
    // const date = new Date();
    // const obj = dateTimePicker.dateTimePicker(date.getFullYear() - 80, date.getFullYear());
    
    // 设置默认值为当前时间
    // const dateTimeIndex = obj.dateTime;
    
    // this.setData({
    //   dateTimeArray: obj.dateTimeArray,
    //   dateTimeIndex: dateTimeIndex
    // });
    
    // 计算农历日期
    // this.updateLunarDate();
    
    // 检查表单是否有效
    this.checkFormValidity();

    // 初始化时检查表单完整性
    this.checkFormComplete();
    
    // 检查是否已有用户信息
    const app = getApp();
    if (app.globalData.userInfo) {
      this.setData({
        hasUserInfo: true,
        userInfo: app.globalData.userInfo
      });
    }
  },

  // 日期时间选择器变化事件
//   bindDateTimeChange: function(e) {
//     this.setData({
//       dateTimeIndex: e.detail.value
//     });
    
//     // 更新农历日期
//     this.updateLunarDate();
    
//     // 检查表单是否有效
//     this.checkFormValidity();
    
//     // 直接调用确认时间的逻辑（无需单独按钮）
//     this.confirmBirthTimeLogic();
//   },

  // 日期时间选择器列变化事件（用于处理2月份日期自动纠错）
//   bindDateTimeColumnChange: function(e) {
//     const column = e.detail.column;
//     const value = e.detail.value;
//     const dateTimeArray = this.data.dateTimeArray;
//     const dateTimeIndex = this.data.dateTimeIndex;

//     dateTimeIndex[column] = value;

//     // 处理月份和日期的联动
//     // if (column === 1) { // 月份列变化
//     //   const year = dateTimeArray[0][dateTimeIndex[0]];
//     //   const month = dateTimeArray[1][value];
//     //   const days = dateTimePicker.getDays(year, month);
      
//     //   dateTimeArray[2] = days;
      
//     //   // 如果当前选择的日期超出了该月的最大天数，则自动调整
//     //   if (dateTimeIndex[2] >= days.length) {
//     //     dateTimeIndex[2] = days.length - 1;
//     //   }
//     // }

//     this.setData({
//       dateTimeArray: dateTimeArray,
//       dateTimeIndex: dateTimeIndex
//     });
    
//     // 更新农历日期
//     this.updateLunarDate();
//   },

  // 更新农历日期
//   updateLunarDate: function() {
//     const dateTimeArray = this.data.dateTimeArray;
//     const dateTimeIndex = this.data.dateTimeIndex;
    
//     if (!dateTimeArray || !dateTimeIndex) return;
    
//     const year = parseInt(dateTimeArray[0][dateTimeIndex[0]]);
//     const month = parseInt(dateTimeArray[1][dateTimeIndex[1]]);
//     const day = parseInt(dateTimeArray[2][dateTimeIndex[2]]);
    
//     // 调用农历转换工具
//     const lunar = lunarCalendar.solar2lunar(year, month, day);
    
//     this.setData({
//       lunarDate: `农历 ${lunar.IMonthCn}${lunar.IDayCn}`
//     });
//   },

  // 切换性别
  toggleGender: function() {
    this.setData({
      gender: this.data.gender === 'male' ? 'female' : 'male'
    });
    
    // 检查表单是否有效
    this.checkFormValidity();
  },

  // 出生地输入事件
//   bindBirthplaceInput: function(e) {
//     this.setData({
//       birthplace: e.detail.value
//     });
    
//     // 检查表单是否有效
//     this.checkFormValidity();
//   },

  // 处理姓氏输入
//   handleLastNameInput: function(e) {
//     const value = e.detail.value;
    
//     // 检查是否全是汉字
//     if (value && !/^[\u4e00-\u9fa5]+$/.test(value)) {
//       // 如果包含非汉字字符，保持原来的值
//       this.setData({
//         lastName: this.data.lastName
//       });
      
//       wx.showToast({
//         title: '请只输入汉字',
//         icon: 'none'
//       });
//       return;
//     }
    
//     this.setData({
//       lastName: value
//     });
    
//     // 检查表单是否有效
//     this.checkFormValidity();
//   },

  // 选择偏好
  selectPreference: function(e) {
    const preferenceType = e.currentTarget.dataset.type;
    this.setData({
      selectedPreference: preferenceType
    });
    this.checkFormComplete();
  },

  // 检查表单是否有效
  checkFormValidity: function() {
    const isValid = this.data.dateTimeIndex !== null && 
                   this.data.gender !== '' && 
                   /^[\u4e00-\u9fa5]+$/.test(this.data.lastName) && // 验证是否为汉字
                   this.data.preference !== ''; // 确保选择了偏好
    
    this.setData({
      isFormValid: isValid
    });
  },

  // 提交信息
  submitInfo: function() {
    if (!this.data.isFormValid) return;
    
    const dateTimeArray = this.data.dateTimeArray;
    const dateTimeIndex = this.data.dateTimeIndex;
    
    // 获取用户输入的信息
    const year = dateTimeArray[0][dateTimeIndex[0]];
    const month = dateTimeArray[1][dateTimeIndex[1]];
    const day = dateTimeArray[2][dateTimeIndex[2]];
    const hour = dateTimeArray[3][dateTimeIndex[3]];
    
    // 处理性别 - 使用统一的gender字段
    // 注意：对于双胞胎的男女组合，默认使用男性计算八字
    let gender = this.data.isTwins ? this.data.genderCombination : this.data.gender;
    const sex = (gender === 'male' || gender === 'male-male' || gender === 'male-female') ? 1 : 0;

    // 保存出生信息到全局数据
    const app = getApp();
    app.globalData.birthInfo = {
      year: year,
      month: month,
      day: day,
      hour: hour,
      gender: gender,
      lastName: this.data.lastName,
      preference: this.data.preference // 添加偏好信息
    };
    
    wx.showLoading({
      title: '正在查询老黄历...'
    });
    
    // 调用八字API
    wx.request({
      url: `https://yisuan.net/app/bazi-wuxing`,
      data: {
        _year: year,
        _month: month,
        _day: day,
        _hour: hour,
        _sex: sex
      },
      success: (res) => {
        const html = res.data;
        try {
          // 解析HTML
          const result = this.parseHTML(html);
          
          // 保存结果到全局数据
          app.globalData.destinyData = result;
          
          // 隐藏加载提示
          wx.hideLoading();
          
          // 跳转到结果页，修正路径
          wx.navigateTo({
            url: '../destiny/destiny'
          });
        } catch (error) {
          console.error('解析八字结果失败:', error);
          wx.hideLoading();
          wx.showToast({
            title: '获取八字信息失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('请求八字API失败:', err);
        wx.hideLoading();
        wx.showToast({
          title: '网络请求失败',
          icon: 'none'
        });
      }
    });
  },

  // 完整的HTML解析方法
  parseHTML: function(html) {
    // 解析八字信息
    const baziReg = /<tr class="has-background-warning">[\s\S]*?<td><b>八字<\/b><\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>/;
    const baziMatch = html.match(baziReg);
    const bazi = baziMatch ? 
      [baziMatch[1], baziMatch[2], baziMatch[3], baziMatch[4]].join('、') : 
      '未找到八字信息';
  
    // 解析五行信息
    const wuxingReg = /<tr class="has-background-warning">[\s\S]*?<td><b>五行<\/b><\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>\s*<td>([^<]+)<\/td>/;
    const wuxingMatch = html.match(wuxingReg);
    const wuxing = wuxingMatch ? 
      [wuxingMatch[1], wuxingMatch[2], wuxingMatch[3], wuxingMatch[4]].join('、') : 
      '未找到五行信息';
  
    // 解析喜用神
    const xiyongReg = /<h3>喜用神：<\/h3>([^<]+)/;
    const xiyongshenMatch = html.match(xiyongReg);
    const xiyongshen = xiyongshenMatch ? 
      xiyongshenMatch[1].replace(/<br>/, '').trim() : 
      '未找到喜用神';
  
    // 解析五行量化得分
    const scoreMap = {};
    const scoreReg = /<label><b>(金|木|水|火|土)：([\d.]+)<\/b><\/label>/g;
    let scoreMatch;
    
    while ((scoreMatch = scoreReg.exec(html)) !== null) {
      const [_, element, value] = scoreMatch;
      scoreMap[element] = parseFloat(value);
    }
  
    // 确保完整五行数据（包含可能缺失的元素）
    ['金','木','水','火','土'].forEach(e => {
      if (!scoreMap.hasOwnProperty(e)) scoreMap[e] = 0;
    });
  
    // 按得分降序排序并格式化
    const sortedScores = Object.entries(scoreMap)
      .sort((a, b) => b[1] - a[1])
      .map(([k, v]) => `${k}：${v.toFixed(3)}`)
      .join('，');
  
    return {
      bazi: bazi,
      wuxing: wuxing,
      xiyongshen: xiyongshen,
      lianghua: sortedScores || '未找到量化得分'
    };
  },

  // 检查表单是否完成
  checkFormComplete: function() {
    const { surname, selectedPreference, fixedChar, fixedCharValue, nameLength, isTwins, gender, genderCombination } = this.data;
    
    // 基本验证：姓氏不能为空，必须选择取名偏好
    let isComplete = surname.trim() !== '' && selectedPreference !== '';
    
    // 验证性别相关选项
    if (isTwins && genderCombination === '') {
      isComplete = false;
    } else if (!isTwins && gender === '') {
      isComplete = false;
    }
    
    // 如果启用了定字取名，固定字也不能为空
    if (nameLength === 'double' && fixedChar && fixedCharValue.trim() === '') {
      isComplete = false;
    }
    
    this.setData({
      formComplete: isComplete
    });
  },

  // 姓氏输入处理
  onSurnameInput: function(e) {
    this.setData({
      surname: e.detail.value
    });
    this.checkFormComplete();
  },

  onSurnameBlur: function(e) {
    // 可以在这里添加姓氏有效性验证
    this.checkFormComplete();
  },

  // 性别选择处理
  onGenderChange: function(e) {
    this.setData({
      gender: e.detail.value
    });
    this.checkFormComplete();
  },

  // 单/双胞胎开关处理
  onTwinsChange: function(e) {
    this.setData({
      isTwins: e.detail.value
    });
    this.checkFormComplete();
  },

  // 性别组合选择处理
  onGenderCombinationChange: function(e) {
    this.setData({
      genderCombination: e.detail.value
    });
    this.checkFormComplete();
  },

  // 名字长度选择处理
  onNameLengthChange: function(e) {
    this.setData({
      nameLength: e.detail.value
    });
    
    // 如果切换到单字，重置定字相关设置
    if (e.detail.value === 'single') {
      this.setData({
        fixedChar: false,
        fixedPosition: 'first',
        fixedCharValue: ''
      });
    }
    
    this.checkFormComplete();
  },

  // 定字取名开关处理
  onFixedCharChange: function(e) {
    this.setData({
      fixedChar: e.detail.value
    });
    
    if (!e.detail.value) {
      this.setData({
        fixedCharValue: ''
      });
    }
    
    this.checkFormComplete();
  },

  // 固定字位置选择处理
  onFixedPositionChange: function(e) {
    this.setData({
      fixedPosition: e.detail.value
    });
    this.checkFormComplete();
  },

  // 固定字输入处理
  onFixedCharInput: function(e) {
    this.setData({
      fixedCharValue: e.detail.value
    });
    this.checkFormComplete();
  },

  onFixedCharBlur: function(e) {
    // 可以在这里添加固定字有效性验证
    this.checkFormComplete();
  },

  // 生僻字开关处理
  onDisableRareCharsChange: function(e) {
    this.setData({
      disableRareChars: e.detail.value
    });
    this.checkFormComplete();
  },

  // 复杂字开关处理
  onDisableComplexCharsChange: function(e) {
    this.setData({
      disableComplexChars: e.detail.value
    });
    this.checkFormComplete();
  },

  // 处理出生时间确认逻辑（与按钮点击分离）
  confirmBirthTimeLogic: function() {
    if (!this.data.dateTimeIndex) {
      wx.showToast({
        title: '请选择完整的出生时间',
        icon: 'none',
        duration: 2000
      });
      return;
    }
  },

  // 处理出生时间确认（保留函数以避免可能的引用错误，但内部改为调用确认逻辑）
  confirmBirthTime: function() {
    this.confirmBirthTimeLogic();
  },

  // 下一步按钮处理
  onNextStep: function() {
    if (!this.data.formComplete) {
      wx.showToast({
        title: '请完成所有必填项',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    // // 如果显示着出生选择器，则需要先确认时间
    // if (this.data.showBirthSelector) {
    //   this.confirmBirthTimeLogic();
    //   // 隐藏出生选择器
    //   this.setData({
    //     showBirthSelector: false
    //   });
    // }
    
    // 保存当前表单数据到全局数据
    const app = getApp();
    if (!app.globalData) {
      app.globalData = {};
    }
    
    // 统一使用gender参数，对于双胞胎情况，使用genderCombination的值
    const formData = {
      surname: this.data.surname,
      gender: this.data.isTwins ? this.data.genderCombination : this.data.gender,
      nameLength: this.data.nameLength,
      fixedChar: this.data.fixedChar,
      fixedPosition: this.data.fixedPosition,
      fixedCharValue: this.data.fixedCharValue,
      disableRareChars: this.data.disableRareChars,
      disableComplexChars: this.data.disableComplexChars,
      selectedPreference: this.data.selectedPreference,
      isTwins: this.data.isTwins
    };
    
    console.log('首页传递的表单数据:', formData);
    
    app.globalData.nameFormData = formData;
    
    // 也将数据存入本地缓存作为备份
    wx.setStorageSync('nameFormData', app.globalData.nameFormData);
    
    // 根据选择的取名偏好进行不同处理
    switch (this.data.selectedPreference) {
      case 'bazi':
        // 八字五行法，跳转到八字页面
        wx.navigateTo({
          url: '../bazi/bazi',
          success: (res) => {
            console.log('导航成功至八字页面');
            // 传递表单数据
            res.eventChannel.emit('formData', formData);
          },
          fail: function(res) {
            console.error('导航失败:', res);
            wx.showToast({
              title: '导航失败: ' + res.errMsg,
              icon: 'none',
              duration: 3000
            });
          }
        });
        break;
        
      case 'culture':
        // 文化典故法，跳转到文化典故页面
        wx.navigateTo({
          url: '../culture/culture',
          success: (res) => {
            console.log('导航成功至文化典故页面');
            // 传递表单数据
            res.eventChannel.emit('formData', formData);
          },
          fail: function(res) {
            console.error('导航失败:', res);
            wx.showToast({
              title: '导航失败: ' + res.errMsg,
              icon: 'none',
              duration: 3000
            });
          }
        });
        break;
        
      case 'combined':
        // 五行典故结合法，跳转到结合页面
        wx.navigateTo({
          url: '../combined/combined',
          success: (res) => {
            console.log('导航成功至五行典故结合页面');
            // 传递表单数据
            res.eventChannel.emit('formData', formData);
          },
          fail: function(res) {
            console.error('导航失败:', res);
            wx.showToast({
              title: '导航失败: ' + res.errMsg,
              icon: 'none',
              duration: 3000
            });
          }
        });
        break;
        
      case 'zodiac':
        // 生肖取名法，跳转到生肖页面
        wx.navigateTo({
          url: '../zodiac/zodiac',
          success: (res) => {
            console.log('导航成功至生肖页面');
            // 传递表单数据
            res.eventChannel.emit('formData', formData);
          },
          fail: function(res) {
            console.error('导航失败:', res);
            wx.showToast({
              title: '导航失败: ' + res.errMsg,
              icon: 'none',
              duration: 3000
            });
          }
        });
        break;
        
      default:
        // 默认情况提示选择取名偏好
        wx.showToast({
          title: '请选择取名偏好',
          icon: 'none',
          duration: 2000
        });
    }
  },
  
  // 创建出生信息输入页面
  createBirthPage: function(source) {
    const app = getApp();
    app.globalData.nameSource = source || 'bazi';
    
    // 尝试导航到已存在的birth页面
    wx.navigateTo({
      url: '../birth/birth',
      success: function(res) {
        console.log('导航到出生信息页成功');
      },
      fail: (res) => {
        console.error('导航到出生信息页失败:', res);
        
        // 如果birth页面不存在，使用自定义弹窗收集出生信息
        wx.showModal({
          title: '输入出生信息',
          content: '八字五行取名需要您的出生信息。请点击确定后收集出生信息。',
          confirmText: '确定',
          cancelText: '取消',
          success: (result) => {
            if (result.confirm) {
              // 在当前页面显示日期选择
              this.showBirthTimeSelector();
            } else {
              wx.showToast({
                title: '请选择其他取名方式',
                icon: 'none',
                duration: 2000
              });
            }
          }
        });
      }
    });
  },
  
  // 显示出生时间选择器
  showBirthTimeSelector: function() {
    this.setData({
      showBirthSelector: true
    });
    
    // 向页面展示时间选择UI
    wx.showToast({
      title: '请选择出生时间',
      icon: 'none',
      duration: 2000
    });
  },
  
  // 处理出生时间确认
  confirmBirthTime: function() {
    if (!this.data.dateTimeIndex) {
      wx.showToast({
        title: '请选择完整的出生时间',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    this.setData({
      showBirthSelector: false
    });
    
    // 调用八字API
    this.calculateBazi();
  },
  
  // 处理八字分析相关导航
  processBaziNavigation: function(source) {
    // 不再使用这个函数，改为createBirthPage
    this.createBirthPage(source);
  },
  
  // 模拟八字数据（当无法获取真实数据时）
  simulateBaziData: function() {
    const app = getApp();
    
    // 创建模拟八字数据
    app.globalData.destinyData = {
      bazi: '甲子、乙丑、丙寅、丁卯',
      wuxing: '木水、木土、火木、火木',
      xiyongshen: '喜水、木，忌火、土',
      lianghua: '水：5.621，木：4.872，金：3.215，土：2.103，火：1.897'
    };
    
    console.log('已创建模拟八字数据');
  },
  
  // 计算八字并导航到命理页面
  calculateBazi: function(source) {
    wx.showLoading({
      title: '正在计算八字...'
    });
    
    const dateTimeArray = this.data.dateTimeArray;
    const dateTimeIndex = this.data.dateTimeIndex;
    
    if (!dateTimeArray || !dateTimeIndex) {
      wx.hideLoading();
      wx.showToast({
        title: '出生时间信息不完整',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    // 获取用户输入的信息
    const year = dateTimeArray[0][dateTimeIndex[0]];
    const month = dateTimeArray[1][dateTimeIndex[1]];
    const day = dateTimeArray[2][dateTimeIndex[2]];
    const hour = dateTimeArray[3][dateTimeIndex[3]];
    
    // 处理性别 - 使用统一的gender字段
    // 注意：对于双胞胎的男女组合，默认使用男性计算八字
    let gender = this.data.isTwins ? this.data.genderCombination : this.data.gender;
    const sex = (gender === 'male' || gender === 'male-male' || gender === 'male-female') ? 1 : 0;
    
    const app = getApp();
    
    // 保存出生信息到全局数据
    app.globalData.birthInfo = {
      year: year,
      month: month,
      day: day,
      hour: hour,
      gender: gender,
      source: source || app.globalData.nameSource || 'bazi'
    };
    
    // 调用八字API
    wx.request({
      url: `https://yisuan.net/app/bazi-wuxing`,
      data: {
        _year: year,
        _month: month,
        _day: day,
        _hour: hour,
        _sex: sex
      },
      success: (res) => {
        try {
          // 解析HTML
          const result = this.parseHTML(res.data);
          
          // 保存结果到全局数据
          app.globalData.destinyData = result;
          
          // 隐藏加载提示
          wx.hideLoading();
          
          // 导航到命理页面
          wx.navigateTo({
            url: '../destiny/destiny',
            success: function(res) {
              console.log('导航到命理页面成功');
            },
            fail: function(res) {
              console.error('导航到命理页面失败:', res);
              wx.showToast({
                title: '导航失败: ' + res.errMsg,
                icon: 'none',
                duration: 3000
              });
            }
          });
        } catch (error) {
          console.error('解析八字结果失败:', error);
          
          // 使用模拟数据
          this.simulateBaziData();
          
          wx.hideLoading();
          
          // 导航到命理页面
          wx.navigateTo({
            url: '../destiny/destiny',
            fail: function(err) {
              console.error('导航失败:', err);
              wx.showToast({
                title: '导航失败: ' + err.errMsg,
                icon: 'none',
                duration: 3000
              });
            }
          });
        }
      },
      fail: (err) => {
        console.error('请求八字API失败:', err);
        
        // 使用模拟数据
        this.simulateBaziData();
        
        wx.hideLoading();
        
        // 导航到命理页面
        wx.navigateTo({
          url: '../destiny/destiny',
          fail: function(error) {
            console.error('导航失败:', error);
            wx.showToast({
              title: '导航失败: ' + error.errMsg,
              icon: 'none',
              duration: 3000
            });
          }
        });
      }
    });
  },

  // 处理用户登录
  handleLogin: function() {
    const that = this;
    wx.getUserProfile({
      desc: '用于完善用户资料',
      success: function(res) {
        const userInfo = res.userInfo;
        console.log('获取用户信息成功:', userInfo);
        
        // 保存用户信息
        const app = getApp();
        app.globalData.userInfo = userInfo;
        wx.setStorageSync('userInfo', userInfo);
        
        // 标记登录状态
        app.globalData.isLoggedIn = true;
        app.globalData.sessionExpired = false;
        
        that.setData({
          hasUserInfo: true,
          userInfo: userInfo
        });
        
        wx.showToast({
          title: '登录成功',
          icon: 'success',
          duration: 2000
        });
      },
      fail: function(err) {
        console.error('获取用户信息失败:', err);
        wx.showToast({
          title: '获取用户信息失败',
          icon: 'none',
          duration: 2000
        });
      }
    });
  }
}) 